home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Systemmonitors / RSys / RSysSrc.lha / RSysPreferenceLists.c < prev    next >
C/C++ Source or Header  |  1993-09-05  |  15KB  |  682 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysPreferenceLists.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void MakeHeadEntry ( int *num , char *title );
  12. *    void MakeHexEntry ( int *num , char *title , APTR entry );
  13. *    void SysEnvList ( void );
  14. *    void SysExtPrinterData ( void );
  15. *    void SysPrefList ( void );
  16. *
  17. *      --- Lokale  Routinen ---
  18. *
  19. *    static void MakeColEntry ( int *num , char *title , long entry );
  20. *    static void MakeMeasureEntry ( int *num , char *title , long entry , char *measure );
  21. *    static void MakeNumEntry ( int *num , char *title , long entry );
  22. *    static void MakeStringEntry ( int *num , char *title , char *entry );
  23. *    static void MakeTimeEntry ( int *num , char *title , struct timeval *tv );
  24. *
  25. * Bemerkungen:
  26. *      Liste der System- und Druckereinstellungen sowie der Env:-Variablen.
  27. *
  28. * Erstellungsdatum:
  29. *      07-Jul-93     Rolf Böhme
  30. *
  31. * Änderungen:
  32. *      07-Jul-93     Rolf Böhme      Erstellung
  33. *
  34. ***************************************************************************
  35. */
  36.  
  37. #include "RSys.h"
  38.  
  39.     /*
  40.      * MakeNumEntry() erzeugt ein Zahleneintrag für die
  41.      * anzuzeigende Liste
  42.      */
  43. static void
  44. MakeNumEntry(int *num, char *title, long entry)
  45. {
  46.     sprintf(Entries[*num].se_Entry, "%-22s : %ld", title, entry);
  47.     AddNodeToList(*num, NO_SORT, 0);
  48.  
  49.     (*num)++;
  50.  
  51.     return;
  52. }
  53.  
  54.     /*
  55.      * MakeStringEntry() erzeugt ein Zeileneintrag für die
  56.      * anzuzeigende Liste
  57.      */
  58. static void
  59. MakeStringEntry(int *num, char *title, char *entry)
  60. {
  61.     sprintf(Entries[*num].se_Entry, "%-22s : %s", title, entry);
  62.     AddNodeToList(*num, NO_SORT, 0);
  63.  
  64.     (*num)++;
  65.  
  66.     return;
  67. }
  68.  
  69.     /*
  70.      * MakeHeadEntry() erzeugt eine Titelzeileneintrag für die
  71.      * anzuzeigende Liste
  72.      */
  73. void
  74. MakeHeadEntry(int *num, char *title)
  75. {
  76.     strcpy(Entries[*num].se_Entry, field[BLANK_FIELD]);
  77.     AddNodeToList(*num, NO_SORT, 0);
  78.  
  79.     (*num)++;
  80.  
  81.     strncpy(Entries[*num].se_Entry, title,BUFSIZE);
  82.     AddNodeToList(*num, NO_SORT, 0);
  83.  
  84.     (*num)++;
  85.  
  86.     return;
  87. }
  88.  
  89.     /*
  90.      * MakeColEntry() erzeugt ein Zahleneintrag für die
  91.      * anzuzeigende Liste in einem bestimmten Format
  92.      */
  93. static void
  94. MakeColEntry(int *num, char *title, long entry)
  95. {
  96.     sprintf(Entries[*num].se_Entry, "%-22s : 0x%04lx", title, (long)entry);
  97.     AddNodeToList(*num, NO_SORT, 0);
  98.  
  99.     (*num)++;
  100.  
  101.     return;
  102. }
  103.  
  104.     /*
  105.      * MakeHexEntry() erzeugt einen hexadezimalen
  106.      * Zahleneintrag für die anzuzeigende Liste
  107.      */
  108. void
  109. MakeHexEntry(int *num, char *title, APTR entry)
  110. {
  111.     sprintf(Entries[*num].se_Entry, "%-14s : 0x%08lx", title, entry);
  112.     AddNodeToList(*num, NO_SORT, 0);
  113.  
  114.     (*num)++;
  115.  
  116.     return;
  117. }
  118.  
  119.     /*
  120.      * MakeTimeEntry() erzeugt einen Zeiteintrag für die
  121.      * anzuzeigende Liste
  122.      */
  123. static void
  124. MakeTimeEntry(int *num, char *title, struct timeval *tv)
  125. {
  126.     sprintf(Entries[*num].se_Entry, "%-22s : %ld sec %-6ld µsec",
  127.               title, tv->tv_secs, tv->tv_micro);
  128.  
  129.     AddNodeToList(*num, NO_SORT, 0);
  130.  
  131.     (*num)++;
  132.  
  133.     return;
  134. }
  135.  
  136.     /*
  137.      * MakeMeasureEntry() erzeugt ein Maßzahleneintrag für die
  138.      * anzuzeigende Liste
  139.      */
  140. static void
  141. MakeMeasureEntry(int *num, char *title, long entry, char *measure)
  142. {
  143.     sprintf(Entries[*num].se_Entry, "%-22s : %ld %s",
  144.               title, (long)entry, measure);
  145.  
  146.     AddNodeToList(*num, NO_SORT, 0);
  147.  
  148.     (*num)++;
  149.  
  150.     return;
  151. }
  152.  
  153.     /*
  154.      * SysPrefList() listet die Preferenceseinstellungen auf.
  155.      * Diese werden NICHT aus den 2.0-IFF-Prefs-Dateien
  156.      * geholt, sondern mit einer Systemfunktion ausgelesen
  157.      */
  158. void
  159. SysPrefList(void)
  160. {
  161.     int    i = 0;
  162.     struct Preferences PrefCopy,
  163.           *PCptr;
  164.     char *prtype = "Printer type",
  165.           *prshade = "Print shade",
  166.           *prpaper = "Paper size",
  167.           *baudrate = "Baud rate",
  168.           *parity = "Parity",
  169.           *handshake = "Handshake",
  170.           *baud = "Baud";
  171.  
  172.     DPOS;
  173.  
  174.    HandleHelp(MN_SysPrefList);
  175.  
  176.     if (PCptr = GetPrefs(&PrefCopy, sizeof(struct Preferences)))
  177.     {
  178.         PrintHeader(PREFS, NULL);
  179.  
  180.         EmptyListView();
  181.  
  182.         PrintInfo("Read Preferences", NO_SPEAK, 0);
  183.  
  184.         countentries = 61;
  185.         Entries = AllocScrollEntries(countentries);
  186.  
  187.         strcpy(Entries[i].se_Entry, "----- Input/Keyboard:");
  188.         AddNodeToList(i++, NO_SORT, 0);
  189.  
  190.         MakeTimeEntry(&i, "Keyboard repeat speed", &PCptr->KeyRptSpeed);
  191.  
  192.         MakeTimeEntry(&i, "Keyboard repeat delay", &PCptr->KeyRptDelay);
  193.  
  194.         MakeTimeEntry(&i, "Double click time", &PCptr->DoubleClick);
  195.  
  196.  
  197.         MakeHeadEntry(&i, "----- Pointer");
  198.  
  199.     /* Intuition Pointer data */
  200.         MakeNumEntry(&i, "\"Hot spot\" X", (long)PCptr->XOffset);
  201.         MakeNumEntry(&i, "\"Hot spot\" Y", (long)PCptr->YOffset);
  202.  
  203.         MakeColEntry(&i, "Pointer Sprite Col 0", (long)PCptr->color17);
  204.         MakeColEntry(&i, "Pointer Sprite Col 1", (long)PCptr->color18);
  205.         MakeColEntry(&i, "Pointer Sprite Col 2", (long)PCptr->color19);
  206.  
  207.         MakeNumEntry(&i, "Pointer Sensitivity", (long)PCptr->PointerTicks);
  208.  
  209.  
  210.  
  211.         MakeHeadEntry(&i, "----- Workbench");
  212.  
  213.         MakeNumEntry(&i, "Height default font", (long)PCptr->FontHeight);
  214.  
  215.         MakeColEntry(&i, "Standard Color 0", (long)PCptr->color0);
  216.         MakeColEntry(&i, "Standard Color 1", (long)PCptr->color1);
  217.         MakeColEntry(&i, "Standard Color 2", (long)PCptr->color2);
  218.         MakeColEntry(&i, "Standard Color 3", (long)PCptr->color3);
  219.  
  220.         MakeNumEntry(&i, "View X-Offset", (long)PCptr->ViewXOffset);
  221.         MakeNumEntry(&i, "View Y-Offset", (long)PCptr->ViewYOffset);
  222.         MakeNumEntry(&i, "View init offset X", (long)PCptr->ViewInitX);
  223.         MakeNumEntry(&i, "View init offset Y", (long)PCptr->ViewInitY);
  224.  
  225.         MakeNumEntry(&i, "Height default font", (long)PCptr->FontHeight);
  226.  
  227.         MakeStringEntry(&i, "CLI availability",
  228.                              (PCptr->EnableCLI ? "CLI enabled" : "CLI disabled"));
  229.  
  230.         MakeStringEntry(&i, "Workbench interlaced",
  231.                              (PCptr->LaceWB ? "Yes" : "No"));
  232.  
  233.         MakeNumEntry(&i, "Override WB width", (long)PCptr->wb_Width);
  234.  
  235.         MakeNumEntry(&i, "Override WB height", (long)PCptr->wb_Height);
  236.  
  237.         MakeNumEntry(&i, "Override WB depth", (long)PCptr->wb_Depth);
  238.  
  239.         MakeNumEntry(&i, "Extension Info size", (long)PCptr->ext_size);
  240.  
  241.  
  242.  
  243.         MakeHeadEntry(&i, "----- Printer");
  244.  
  245.         MakeStringEntry(&i, "Printer port",
  246.                              (PCptr->PrinterPort ? "Serial port" : "Parallel port"));
  247.  
  248.         switch (PCptr->PrinterType)
  249.         {
  250.             case 0x00:
  251.                 MakeStringEntry(&i, prtype, "Custom");
  252.                 break;
  253.  
  254.             case 0x01:
  255.                 MakeStringEntry(&i, prtype, "Alpha P101");
  256.                 break;
  257.  
  258.             case 0x02:
  259.                 MakeStringEntry(&i, prtype, "Brother 15XL");
  260.                 break;
  261.  
  262.             case 0x03:
  263.                 MakeStringEntry(&i, prtype, "CBM MPS1000");
  264.                 break;
  265.  
  266.             case 0x04:
  267.                 MakeStringEntry(&i, prtype, "Diabolo 630");
  268.                 break;
  269.  
  270.             case 0x05:
  271.                 MakeStringEntry(&i, prtype, "Diabolo ADV-D25");
  272.                 break;
  273.  
  274.             case 0x06:
  275.                 MakeStringEntry(&i, prtype, "Diabolo C-150");
  276.                 break;
  277.  
  278.             case 0x07:
  279.                 MakeStringEntry(&i, prtype, "Epson");
  280.                 break;
  281.  
  282.             case 0x08:
  283.                 MakeStringEntry(&i, prtype, "Epson JX-80");
  284.                 break;
  285.  
  286.             case 0x09:
  287.                 MakeStringEntry(&i, prtype, "Okimate 20");
  288.                 break;
  289.  
  290.             case 0x0A:
  291.                 MakeStringEntry(&i, prtype, "Qume-LP 20");
  292.                 break;
  293.  
  294.             case 0x0B:
  295.                 MakeStringEntry(&i, prtype, "HP-Laserjet");
  296.                 break;
  297.  
  298.             case 0x0C:
  299.                 MakeStringEntry(&i, prtype, "HP-Laserjet +");
  300.                 break;
  301.  
  302.             default:
  303.                 MakeStringEntry(&i, prtype, "Unknown");
  304.                 break;
  305.         }
  306.  
  307.         MakeStringEntry(&i, "Printer Driver", (char *)PCptr->PrinterFilename);
  308.  
  309.         MakeNumEntry(&i, "Print pitch", (long)PCptr->PrintPitch);
  310.  
  311.         MakeStringEntry(&i, "Print quality",
  312.                              (PCptr->PrintQuality ? "Letter" : "Draft"));
  313.  
  314.         MakeStringEntry(&i, "Lines per inch",
  315.                              (PCptr->PrintSpacing ? "8 LPI" : "6 LPI"));
  316.  
  317.         MakeNumEntry(&i, "Left margin", (long)PCptr->PrintLeftMargin);
  318.  
  319.         MakeMeasureEntry(&i, "Right margin", (long)PCptr->PrintRightMargin,
  320.                               "Chars");
  321.  
  322.         MakeStringEntry(&i, "Print image",
  323.                              (PCptr->PrintImage ? "Negative" : "Positive"));
  324.  
  325.         MakeStringEntry(&i, "Print aspect",
  326.                              (PCptr->PrintImage ? "Vertical" : "Horizontal"));
  327.  
  328.  
  329.         switch (PCptr->PrintShade)
  330.         {
  331.             case 0:
  332.                 MakeStringEntry(&i, prshade, "Black/White");
  333.                 break;
  334.  
  335.             case 1:
  336.                 MakeStringEntry(&i, prshade, "Grey scale");
  337.                 break;
  338.  
  339.             default:
  340.                 MakeStringEntry(&i, prshade, "Color");
  341.                 break;
  342.         }
  343.  
  344.         MakeNumEntry(&i, "Print Threshold", (long)PCptr->PrintThreshold);
  345.  
  346.         switch (PCptr->PaperSize)
  347.         {
  348.             case US_LETTER:
  349.                 MakeStringEntry(&i, prpaper, "USA Letter");
  350.                 break;
  351.  
  352.             case US_LEGAL:
  353.                 MakeStringEntry(&i, prpaper, "USA Legal");
  354.                 break;
  355.  
  356.             case N_TRACTOR:
  357.                 MakeStringEntry(&i, prpaper, "Narrow tractor");
  358.                 break;
  359.  
  360.             case W_TRACTOR:
  361.                 MakeStringEntry(&i, prpaper, "Wide tractor");
  362.                 break;
  363.  
  364.             case CUSTOM:
  365.                 MakeStringEntry(&i, prpaper, "Custom width");
  366.                 break;
  367.  
  368.         }
  369.  
  370.         MakeMeasureEntry(&i, "Paper length", (long)PCptr->PaperLength,
  371.                               "Rows");
  372.  
  373.         MakeStringEntry(&i, "Paper type",
  374.                              (PCptr->PaperType ? "Single paper" : "Fanfold paper"));
  375.  
  376.         MakeStringEntry(&i, "Temp file for printer",
  377.                              ((PCptr->WorkName != NULL) ? (char *)PCptr->WorkName :
  378.                               (char *)"None"));
  379.  
  380.         MakeNumEntry(&i, "Affect Rows/Columns", (long)PCptr->RowSizeChange);
  381.  
  382.         sprintf(Entries[i].se_Entry, "User preference flags  : 0x%08lx",
  383.                   PCptr->PrintFlags);
  384.         AddNodeToList(i++, NO_SORT, 0);
  385.  
  386.         MakeMeasureEntry(&i, "Max width of picture", (long)PCptr->PrintMaxWidth / 10,
  387.                               "inch");
  388.  
  389.         MakeMeasureEntry(&i, "Max height of picture", (long)PCptr->PrintMaxHeight / 10,
  390.                               "inch");
  391.         MakeMeasureEntry(&i, "Offset of picture", (long)PCptr->PrintXOffset / 10,
  392.                               "inch");
  393.         MakeNumEntry(&i, "Print density", (long)PCptr->PrintDensity);
  394.  
  395.  
  396.  
  397.         MakeHeadEntry(&i, "----- Serial configuration");
  398.  
  399.         switch (PCptr->BaudRate)
  400.         {
  401.             case 0x00:
  402.                 MakeMeasureEntry(&i, baudrate, 110L, baud);
  403.                 break;
  404.  
  405.             case 0x01:
  406.                 MakeMeasureEntry(&i, baudrate, 300L, baud);
  407.                 break;
  408.  
  409.             case 0x02:
  410.                 MakeMeasureEntry(&i, baudrate, 1200L, baud);
  411.                 break;
  412.  
  413.             case 0x03:
  414.                 MakeMeasureEntry(&i, baudrate, 2400L, baud);
  415.                 break;
  416.  
  417.             case 0x04:
  418.                 MakeMeasureEntry(&i, baudrate, 4800L, baud);
  419.                 break;
  420.  
  421.             case 0x05:
  422.                 MakeMeasureEntry(&i, baudrate, 9600L, baud);
  423.                 break;
  424.  
  425.             case 0x06:
  426.                 MakeMeasureEntry(&i, baudrate, 19200L, baud);
  427.                 break;
  428.  
  429.             case 0x07:
  430.                 MakeStringEntry(&i, baudrate, "MIDI (31.250 baud)");
  431.                 break;
  432.  
  433.             default:
  434.                 MakeStringEntry(&i, baudrate, (char *)field[NO_BAUD]);
  435.                 break;
  436.         }
  437.  
  438.         MakeNumEntry(&i, "Read bits", (long)SRBNUM(PCptr->SerRWBits));
  439.         MakeNumEntry(&i, "Write bits", (long)SWBNUM(PCptr->SerRWBits));
  440.  
  441.         MakeNumEntry(&i, "Stop bits", (long)SSBNUM(PCptr->SerStopBuf));
  442.  
  443.         switch (SPARNUM(PCptr->SerParShk))
  444.         {
  445.             case SPARITY_NONE:
  446.                 MakeStringEntry(&i, parity, "None");
  447.                 break;
  448.  
  449.             case SPARITY_EVEN:
  450.                 MakeStringEntry(&i, parity, "Even");
  451.                 break;
  452.  
  453.             case SPARITY_ODD:
  454.                 MakeStringEntry(&i, parity, "Odd");
  455.                 break;
  456.  
  457.             default:
  458.                 MakeStringEntry(&i, parity, (char *)field[NO_PARITY]);
  459.                 break;
  460.         }
  461.  
  462.         switch (SHAKNUM(PCptr->SerParShk))
  463.         {
  464.             case SHSHAKE_XON:
  465.                 MakeStringEntry(&i, handshake, "XOn/XOff");
  466.                 break;
  467.  
  468.             case SHSHAKE_RTS:
  469.                 MakeStringEntry(&i, handshake, "RTS/CTS");
  470.                 break;
  471.  
  472.             case SHSHAKE_NONE:
  473.                 MakeStringEntry(&i, handshake, "None");
  474.                 break;
  475.  
  476.             default:
  477.                 MakeStringEntry(&i, handshake, (char *)field[NO_HANDSHK]);
  478.                 break;
  479.         }
  480.     }
  481.     else ErrorHandle("GetPrefs()", ENV_ERR, INFO_FAIL, NO_KILL);
  482.  
  483.     PrintStatistics();
  484.  
  485.     return;
  486. }
  487.  
  488.  
  489.     /*
  490.      * SysEnvList() erzeugt eine Liste aller Dateien
  491.      * (Environmentvariablen) im Verzeichnis ENV:
  492.      */
  493. void
  494. SysEnvList(void)
  495. {
  496.     int    i;
  497.     UBYTE envline[MAXFULLNAME+1];
  498.     char    envname[ENVLEN+1], envfullname[MAXFULLNAME];
  499.     struct ExAllControl *eac;
  500.     struct ExAllData *EAData,
  501.           *ead;
  502.     int    more;
  503.     long    s;
  504.     int    d = 0;
  505.     BPTR    lock;
  506.     int ftyp;
  507.  
  508.     DPOS;
  509.  
  510.    HandleHelp(MN_SysEnvList);
  511.  
  512.     PrintHeader(ENVVARS, NULL);
  513.  
  514.     EmptyListView();
  515.  
  516.     if (lock = Lock((UBYTE *) "ENV:", ACCESS_READ))
  517.     {
  518.         countentries = SizeOfDir(lock, &s, &d);
  519.         countentries += d;
  520.  
  521.         if (NoEntries())
  522.         {
  523.             UnLock(lock);
  524.             return;
  525.         }
  526.  
  527.         Entries = AllocScrollEntries(countentries);
  528.  
  529.         i = 0;
  530.  
  531.         if (eac = AllocDosObject(DOS_EXALLCONTROL, NULL))
  532.         {
  533.             eac->eac_LastKey = 0;
  534.  
  535.             EAData = MyAllocVec((MAXLARGEMEM+1) * sizeof(struct ExAllData),
  536.                                       MEMF_ANY | MEMF_CLEAR, NO_KILL);
  537.  
  538.             if (EAData)
  539.             {
  540.                 do
  541.                 {
  542.                     more = ExAll(lock, EAData, MAXLARGEMEM * sizeof(struct ExAllData),
  543.                                      ED_TYPE, eac);
  544.  
  545.                     if ((!more) && (IoErr()!= ERROR_NO_MORE_ENTRIES))
  546.                     {
  547.                         ErrorHandle("ENV:", DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  548.                         break;
  549.                     }
  550.  
  551.                     if (eac->eac_Entries == 0)
  552.                         continue;
  553.  
  554.                     ead = EAData;
  555.  
  556.                     do
  557.                     {
  558.                         strncpy(envname, (char *)ead->ed_Name, ENVLEN);
  559.                         envname[ENVLEN] = STRINGEND;
  560.                         sprintf(envfullname,"ENV:%s",envname);
  561.  
  562.                         ftyp    = filetype((char *)envfullname);
  563.  
  564.                         if(ead->ed_Type > 0)
  565.                             sprintf(Entries[i].se_Entry,EntryAttr[ENVVARS].ea_dataformat,
  566.                                       envname, "<dir>");
  567.                         else if(ftyp == TYPE_TEXT)
  568.                         {
  569.                             if (GetVar((STRPTR)envname, envline, MAXFULLNAME,GVF_GLOBAL_ONLY) > 0)
  570.                             {
  571.                                 envline[MAXSTRLEN-1] = STRINGEND;
  572.  
  573.                                 sprintf(Entries[i].se_Entry, EntryAttr[ENVVARS].ea_dataformat,
  574.                                           envname, (char *)envline);
  575.                             }
  576.                             else
  577.                                 sprintf(Entries[i].se_Entry,
  578.                                           EntryAttr[ENVVARS].ea_dataformat,
  579.                                           envname, "<env error>");
  580.                         }
  581.                         else
  582.                             sprintf(Entries[i].se_Entry,
  583.                                       EntryAttr[ENVVARS].ea_dataformat,
  584.                                       envname, "<no text>");
  585.  
  586.                         AddNodeToList(i++, SORT, 0);
  587.  
  588.                         ead = ead->ed_Next;
  589.                     }
  590.                     while (ead && (i < countentries));
  591.                 }
  592.                 while (more && (i < countentries));
  593.  
  594.                 MyFreeVec(EAData);
  595.             }
  596.  
  597.             FreeDosObject(DOS_EXALLCONTROL, eac);
  598.         }
  599.         else ErrorHandle("AllocDosObject()", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  600.  
  601.         UnLock(lock);
  602.     }
  603.     else
  604.     {
  605.         ErrorHandle("ENV:-Lock", ENV_ERR, FIND_FAIL, NO_KILL);
  606.         return;
  607.     }
  608.  
  609.     PrintStatistics();
  610.  
  611.     return;
  612. }
  613.  
  614.  
  615.  
  616. void
  617. SysExtPrinterData(void)
  618. {
  619.     union printerIO
  620.     {
  621.          struct IOStdReq      ios;
  622.          struct IODRPReq      iodrp;
  623.          struct IOPrtCmdReq iopc;
  624.     } *PIO;
  625.     struct MsgPort *PrinterMP;
  626.     struct PrinterData *PD;
  627.     struct PrinterExtendedData *PED;
  628.     int i = 0;
  629.  
  630.     DPOS;
  631.  
  632.    HandleHelp(MN_SysExtPrinterData);
  633.  
  634.     PrintHeader(PRINTERDATA, NULL);
  635.  
  636.     EmptyListView();
  637.  
  638.     countentries = 13;
  639.     Entries = AllocScrollEntries(countentries);
  640.  
  641.     if (PrinterMP = (struct MsgPort *) CreateMsgPort())
  642.     {
  643.         if (PIO = (union printerIO *) CreateExtIO(PrinterMP,
  644.                                                                 sizeof(union printerIO)))
  645.         {
  646.             if (!(OpenDevice((STRPTR)"printer.device", 0,
  647.                                   (struct IORequest *) PIO, 0)))
  648.             {
  649.                 PD = (struct PrinterData *) PIO->iodrp.io_Device;
  650.                 PED = (struct PrinterExtendedData *) &PD->pd_SegmentData->ps_PED;
  651.  
  652.                 MakeStringEntry(&i,"Printer name",PED->ped_PrinterName);
  653.                 MakeNumEntry(&i,"Version",(long)PD->pd_SegmentData->ps_Version);
  654.                 MakeNumEntry(&i,"Revision",(long)PD->pd_SegmentData->ps_Revision);
  655.  
  656.                 MakeNumEntry(&i,"Printer class",(long)PED->ped_PrinterClass);
  657.                 MakeNumEntry(&i,"Color class",(long)PED->ped_ColorClass);
  658.  
  659.                 MakeNumEntry(&i,"Print columns",(long)PED->ped_MaxColumns);
  660.                 MakeNumEntry(&i,"Char sets",(long)PED->ped_NumCharSets);
  661.                 MakeNumEntry(&i,"Print head pins",(long)PED->ped_NumRows);
  662.  
  663.                 MakeMeasureEntry(&i,"Max X-dots in dump",PED->ped_MaxXDots,"dots");
  664.                 MakeMeasureEntry(&i,"Max Y-dots in dump",PED->ped_MaxYDots,"dots");
  665.                 MakeMeasureEntry(&i,"Density X",(long)PED->ped_XDotsInch,"dots/inch");
  666.                 MakeMeasureEntry(&i,"Density Y",(long)PED->ped_YDotsInch,"dots/inch");
  667.                 MakeMeasureEntry(&i,"Timeout",(long)PED->ped_TimeoutSecs,"sec");
  668.  
  669.                 CloseDevice((struct IORequest *) PIO);
  670.             }
  671.  
  672.             DeleteExtIO((struct IORequest *) PIO);
  673.         }
  674.  
  675.         DeleteMsgPort((struct MsgPort *) PrinterMP);
  676.     }
  677.  
  678.     PrintStatistics();
  679.  
  680.     return;
  681. }
  682.